package main

import (
	"fmt"
	"sort"
	"strconv"
)

type IT int

var aa IT = 5

func main() {
	//简单类型转换 valueOfTypeB = typeB(valueOfTypeA)
	a := 5.0
	b := int(a)
	fmt.Printf("value = %d \n", b)

	bb := int(5)
	c := IT(bb)
	fmt.Printf("value = %d\n", c)

	fmt.Println("int - > string " + strconv.Itoa(32))

	//数值string 转换成 int
	i, _ := strconv.Atoi("32")
	fmt.Println(3 + i)

	//字符string 转换成 int 报错处理
	i, err := strconv.Atoi("a")
	if err != nil {
		fmt.Println("converted failed")
	}

	bbb, err := strconv.ParseBool("true")
	if err != nil {
		fmt.Println("converted failed")
	} else {
		fmt.Println(bbb)
	}

	f, err := strconv.ParseFloat("3.1415", 64)
	if err != nil {
		fmt.Println("converted failed")
	} else {
		fmt.Println(f)
	}

	//	g, err := strconv.ParseInt("-42", 10, 64)
	g, err := strconv.ParseUint("42", 10, 64)
	if err != nil {
		fmt.Println("converted failed")
	} else {
		fmt.Println(g)
	}

	//阶乘 公式 n * (n-1)
	jc(10)
	//费波那奇数列 公式 f(n)= f(n-1)+f(n-2)
	fb(10)
	fff := func(a, b int) int {
		return a + b
	}
	added("a+b", fff)
	mm := added2()
	fmt.Println(mm(11, 22))
	//回调函数
	s1 := []int{112, 22, 52, 32, 12}
	less := func(i, j int) bool {
		fmt.Println("来了老弟")
		//降序
		//		return s1[i] > s1[j]
		//升序
		return s1[i] < s1[j]
	}
	sort.SliceStable(s1, less)
	fmt.Println(s1)
	//将函数的返回结果"闭包"赋值给变量a
	nfa := nf(3)
	//调用存储在变量中的闭包函数
	nfres := nfa(5)
	fmt.Println(nfres)
	//可以直接调用闭包
	//因为闭包没有赋值给变量，所以它称为匿名闭包
	fmt.Println(nf(5)(5))

}

//匿名闭包

func nf(x int) func(int) int {
	g := func(y int) int {
		return x + y
	}
	return g
}

//函数作为参数

func added(msg string, a func(a, b int) int) {
	fmt.Println(msg, ":", a(33, 44))
}

//函数返回另一个函数
func added2() func(a, b int) int {
	f := func(a, b int) int {
		return a + b
	}
	return f
}

func jc(n int) int {
	if n == 1 {
		return 1
	}
	return n * jc(n-1)
}
func fb(n int) int {
	if n == 1 || n == 2 {
		return n
	}
	return fb(n-1) + fb(n-2)
}
